home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 2010 April / PCWorld0410.iso / hity wydania / Ubuntu 9.10 PL / karmelkowy-koliberek-desktop-9.10-i386-PL.iso / casper / filesystem.squashfs / usr / lib / python2.6 / xmllib.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2009-11-11  |  27KB  |  992 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. '''A parser for XML, using the derived class as static DTD.'''
  5. import re
  6. import string
  7. import warnings
  8. warnings.warn('The xmllib module is obsolete.  Use xml.sax instead.', DeprecationWarning, 2)
  9. del warnings
  10. version = '0.3'
  11.  
  12. class Error(RuntimeError):
  13.     pass
  14.  
  15. _S = '[ \t\r\n]+'
  16. _opS = '[ \t\r\n]*'
  17. _Name = '[a-zA-Z_:][-a-zA-Z0-9._:]*'
  18. _QStr = '(?:\'[^\']*\'|"[^"]*")'
  19. illegal = re.compile('[^\t\r\n -~\xa0-\xff]')
  20. interesting = re.compile('[]&<]')
  21. amp = re.compile('&')
  22. ref = re.compile('&(' + _Name + '|#[0-9]+|#x[0-9a-fA-F]+)[^-a-zA-Z0-9._:]')
  23. entityref = re.compile('&(?P<name>' + _Name + ')[^-a-zA-Z0-9._:]')
  24. charref = re.compile('&#(?P<char>[0-9]+[^0-9]|x[0-9a-fA-F]+[^0-9a-fA-F])')
  25. space = re.compile(_S + '$')
  26. newline = re.compile('\n')
  27. attrfind = re.compile(_S + '(?P<name>' + _Name + ')(' + _opS + '=' + _opS + '(?P<value>' + _QStr + '|[-a-zA-Z0-9.:+*%?!\\(\\)_#=~]+))?')
  28. starttagopen = re.compile('<' + _Name)
  29. starttagend = re.compile(_opS + '(?P<slash>/?)>')
  30. starttagmatch = re.compile('<(?P<tagname>' + _Name + ')(?P<attrs>(?:' + attrfind.pattern + ')*)' + starttagend.pattern)
  31. endtagopen = re.compile('</')
  32. endbracket = re.compile(_opS + '>')
  33. endbracketfind = re.compile('(?:[^>\'"]|' + _QStr + ')*>')
  34. tagfind = re.compile(_Name)
  35. cdataopen = re.compile('<!\\[CDATA\\[')
  36. cdataclose = re.compile('\\]\\]>')
  37. _SystemLiteral = '(?P<%s>' + _QStr + ')'
  38. _PublicLiteral = '(?P<%s>"[-\'\\(\\)+,./:=?;!*#@$_%% \n\ra-zA-Z0-9]*"|\'[-\\(\\)+,./:=?;!*#@$_%% \n\ra-zA-Z0-9]*\')'
  39. _ExternalId = '(?:SYSTEM|PUBLIC' + _S + _PublicLiteral % 'pubid' + ')' + _S + _SystemLiteral % 'syslit'
  40. doctype = re.compile('<!DOCTYPE' + _S + '(?P<name>' + _Name + ')(?:' + _S + _ExternalId + ')?' + _opS)
  41. xmldecl = re.compile('<\\?xml' + _S + 'version' + _opS + '=' + _opS + '(?P<version>' + _QStr + ')' + '(?:' + _S + 'encoding' + _opS + '=' + _opS + '(?P<encoding>\'[A-Za-z][-A-Za-z0-9._]*\'|"[A-Za-z][-A-Za-z0-9._]*"))?(?:' + _S + 'standalone' + _opS + '=' + _opS + '(?P<standalone>\'(?:yes|no)\'|"(?:yes|no)"))?' + _opS + '\\?>')
  42. procopen = re.compile('<\\?(?P<proc>' + _Name + ')' + _opS)
  43. procclose = re.compile(_opS + '\\?>')
  44. commentopen = re.compile('<!--')
  45. commentclose = re.compile('-->')
  46. doubledash = re.compile('--')
  47. attrtrans = string.maketrans(' \r\n\t', '    ')
  48. _NCName = '[a-zA-Z_][-a-zA-Z0-9._]*'
  49. ncname = re.compile(_NCName + '$')
  50. qname = re.compile('(?:(?P<prefix>' + _NCName + '):)?(?P<local>' + _NCName + ')$')
  51. xmlns = re.compile('xmlns(?::(?P<ncname>' + _NCName + '))?$')
  52.  
  53. class XMLParser:
  54.     attributes = { }
  55.     elements = { }
  56.     __accept_unquoted_attributes = 0
  57.     __accept_missing_endtag_name = 0
  58.     __map_case = 0
  59.     __accept_utf8 = 0
  60.     __translate_attribute_references = 1
  61.     
  62.     def __init__(self, **kw):
  63.         self._XMLParser__fixed = 0
  64.         if 'accept_unquoted_attributes' in kw:
  65.             self._XMLParser__accept_unquoted_attributes = kw['accept_unquoted_attributes']
  66.         
  67.         if 'accept_missing_endtag_name' in kw:
  68.             self._XMLParser__accept_missing_endtag_name = kw['accept_missing_endtag_name']
  69.         
  70.         if 'map_case' in kw:
  71.             self._XMLParser__map_case = kw['map_case']
  72.         
  73.         if 'accept_utf8' in kw:
  74.             self._XMLParser__accept_utf8 = kw['accept_utf8']
  75.         
  76.         if 'translate_attribute_references' in kw:
  77.             self._XMLParser__translate_attribute_references = kw['translate_attribute_references']
  78.         
  79.         self.reset()
  80.  
  81.     
  82.     def __fixelements(self):
  83.         self._XMLParser__fixed = 1
  84.         self.elements = { }
  85.         self._XMLParser__fixdict(self.__dict__)
  86.         self._XMLParser__fixclass(self.__class__)
  87.  
  88.     
  89.     def __fixclass(self, kl):
  90.         self._XMLParser__fixdict(kl.__dict__)
  91.         for k in kl.__bases__:
  92.             self._XMLParser__fixclass(k)
  93.         
  94.  
  95.     
  96.     def __fixdict(self, dict):
  97.         for key in dict.keys():
  98.             if key[:6] == 'start_':
  99.                 tag = key[6:]
  100.                 (start, end) = self.elements.get(tag, (None, None))
  101.                 if start is None:
  102.                     self.elements[tag] = (getattr(self, key), end)
  103.                 
  104.             start is None
  105.             if key[:4] == 'end_':
  106.                 tag = key[4:]
  107.                 (start, end) = self.elements.get(tag, (None, None))
  108.                 if end is None:
  109.                     self.elements[tag] = (start, getattr(self, key))
  110.                 
  111.             end is None
  112.         
  113.  
  114.     
  115.     def reset(self):
  116.         self.rawdata = ''
  117.         self.stack = []
  118.         self.nomoretags = 0
  119.         self.literal = 0
  120.         self.lineno = 1
  121.         self._XMLParser__at_start = 1
  122.         self._XMLParser__seen_doctype = None
  123.         self._XMLParser__seen_starttag = 0
  124.         self._XMLParser__use_namespaces = 0
  125.         self._XMLParser__namespaces = {
  126.             'xml': None }
  127.         if self.elements is XMLParser.elements:
  128.             self._XMLParser__fixelements()
  129.         
  130.  
  131.     
  132.     def setnomoretags(self):
  133.         self.nomoretags = self.literal = 1
  134.  
  135.     
  136.     def setliteral(self, *args):
  137.         self.literal = 1
  138.  
  139.     
  140.     def feed(self, data):
  141.         self.rawdata = self.rawdata + data
  142.         self.goahead(0)
  143.  
  144.     
  145.     def close(self):
  146.         self.goahead(1)
  147.         if self._XMLParser__fixed:
  148.             self._XMLParser__fixed = 0
  149.             del self.elements
  150.         
  151.  
  152.     
  153.     def translate_references(self, data, all = 1):
  154.         if not self._XMLParser__translate_attribute_references:
  155.             return data
  156.         i = 0
  157.         while None:
  158.             res = amp.search(data, i)
  159.             if res is None:
  160.                 return data
  161.             s = res.start(0)
  162.             res = ref.match(data, s)
  163.             i = res.end(0)
  164.             str = res.group(1)
  165.             rescan = 0
  166.             if str[0] == '#':
  167.                 if str[1] == 'x':
  168.                     str = chr(int(str[2:], 16))
  169.                 else:
  170.                     str = chr(int(str[1:]))
  171.                 if data[i - 1] != ';':
  172.                     self.syntax_error("`;' missing after char reference")
  173.                     i = i - 1
  174.                 
  175.             elif all:
  176.                 if str in self.entitydefs:
  177.                     str = self.entitydefs[str]
  178.                     rescan = 1
  179.                 elif data[i - 1] != ';':
  180.                     self.syntax_error("bogus `&'")
  181.                     i = s + 1
  182.                     continue
  183.                 else:
  184.                     self.syntax_error("reference to unknown entity `&%s;'" % str)
  185.                     str = '&' + str + ';'
  186.             elif data[i - 1] != ';':
  187.                 self.syntax_error("bogus `&'")
  188.                 i = s + 1
  189.                 continue
  190.             
  191.             data = data[:s] + str + data[i:]
  192.             if rescan:
  193.                 i = s
  194.                 continue
  195.             i = s + len(str)
  196.             continue
  197.             return None
  198.  
  199.     
  200.     def getnamespace(self):
  201.         nsdict = { }
  202.         for t, d, nst in self.stack:
  203.             nsdict.update(d)
  204.         
  205.         return nsdict
  206.  
  207.     
  208.     def goahead(self, end):
  209.         rawdata = self.rawdata
  210.         i = 0
  211.         n = len(rawdata)
  212.         while i < n:
  213.             if i > 0:
  214.                 self._XMLParser__at_start = 0
  215.             
  216.             if self.nomoretags:
  217.                 data = rawdata[i:n]
  218.                 self.handle_data(data)
  219.                 self.lineno = self.lineno + data.count('\n')
  220.                 i = n
  221.                 break
  222.             
  223.             res = interesting.search(rawdata, i)
  224.             if res:
  225.                 j = res.start(0)
  226.             else:
  227.                 j = n
  228.             if i < j:
  229.                 data = rawdata[i:j]
  230.                 if self._XMLParser__at_start and space.match(data) is None:
  231.                     self.syntax_error('illegal data at start of file')
  232.                 
  233.                 self._XMLParser__at_start = 0
  234.                 if not (self.stack) and space.match(data) is None:
  235.                     self.syntax_error('data not in content')
  236.                 
  237.                 if not (self._XMLParser__accept_utf8) and illegal.search(data):
  238.                     self.syntax_error('illegal character in content')
  239.                 
  240.                 self.handle_data(data)
  241.                 self.lineno = self.lineno + data.count('\n')
  242.             
  243.             i = j
  244.             if i == n:
  245.                 break
  246.             
  247.             if rawdata[i] == '<':
  248.                 if starttagopen.match(rawdata, i):
  249.                     if self.literal:
  250.                         data = rawdata[i]
  251.                         self.handle_data(data)
  252.                         self.lineno = self.lineno + data.count('\n')
  253.                         i = i + 1
  254.                         continue
  255.                     
  256.                     k = self.parse_starttag(i)
  257.                     if k < 0:
  258.                         break
  259.                     
  260.                     self._XMLParser__seen_starttag = 1
  261.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  262.                     i = k
  263.                     continue
  264.                 
  265.                 if endtagopen.match(rawdata, i):
  266.                     k = self.parse_endtag(i)
  267.                     if k < 0:
  268.                         break
  269.                     
  270.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  271.                     i = k
  272.                     continue
  273.                 
  274.                 if commentopen.match(rawdata, i):
  275.                     if self.literal:
  276.                         data = rawdata[i]
  277.                         self.handle_data(data)
  278.                         self.lineno = self.lineno + data.count('\n')
  279.                         i = i + 1
  280.                         continue
  281.                     
  282.                     k = self.parse_comment(i)
  283.                     if k < 0:
  284.                         break
  285.                     
  286.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  287.                     i = k
  288.                     continue
  289.                 
  290.                 if cdataopen.match(rawdata, i):
  291.                     k = self.parse_cdata(i)
  292.                     if k < 0:
  293.                         break
  294.                     
  295.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  296.                     i = k
  297.                     continue
  298.                 
  299.                 res = xmldecl.match(rawdata, i)
  300.                 if res:
  301.                     if not self._XMLParser__at_start:
  302.                         self.syntax_error('<?xml?> declaration not at start of document')
  303.                     
  304.                     (version, encoding, standalone) = res.group('version', 'encoding', 'standalone')
  305.                     if version[1:-1] != '1.0':
  306.                         raise Error('only XML version 1.0 supported')
  307.                     version[1:-1] != '1.0'
  308.                     if encoding:
  309.                         encoding = encoding[1:-1]
  310.                     
  311.                     if standalone:
  312.                         standalone = standalone[1:-1]
  313.                     
  314.                     self.handle_xml(encoding, standalone)
  315.                     i = res.end(0)
  316.                     continue
  317.                 
  318.                 res = procopen.match(rawdata, i)
  319.                 if res:
  320.                     k = self.parse_proc(i)
  321.                     if k < 0:
  322.                         break
  323.                     
  324.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  325.                     i = k
  326.                     continue
  327.                 
  328.                 res = doctype.match(rawdata, i)
  329.                 if res:
  330.                     if self.literal:
  331.                         data = rawdata[i]
  332.                         self.handle_data(data)
  333.                         self.lineno = self.lineno + data.count('\n')
  334.                         i = i + 1
  335.                         continue
  336.                     
  337.                     if self._XMLParser__seen_doctype:
  338.                         self.syntax_error('multiple DOCTYPE elements')
  339.                     
  340.                     if self._XMLParser__seen_starttag:
  341.                         self.syntax_error('DOCTYPE not at beginning of document')
  342.                     
  343.                     k = self.parse_doctype(res)
  344.                     if k < 0:
  345.                         break
  346.                     
  347.                     self._XMLParser__seen_doctype = res.group('name')
  348.                     if self._XMLParser__map_case:
  349.                         self._XMLParser__seen_doctype = self._XMLParser__seen_doctype.lower()
  350.                     
  351.                     self.lineno = self.lineno + rawdata[i:k].count('\n')
  352.                     i = k
  353.                     continue
  354.                 
  355.             elif rawdata[i] == '&':
  356.                 if self.literal:
  357.                     data = rawdata[i]
  358.                     self.handle_data(data)
  359.                     i = i + 1
  360.                     continue
  361.                 
  362.                 res = charref.match(rawdata, i)
  363.                 if res is not None:
  364.                     i = res.end(0)
  365.                     if rawdata[i - 1] != ';':
  366.                         self.syntax_error("`;' missing in charref")
  367.                         i = i - 1
  368.                     
  369.                     if not self.stack:
  370.                         self.syntax_error('data not in content')
  371.                     
  372.                     self.handle_charref(res.group('char')[:-1])
  373.                     self.lineno = self.lineno + res.group(0).count('\n')
  374.                     continue
  375.                 
  376.                 res = entityref.match(rawdata, i)
  377.                 if res is not None:
  378.                     i = res.end(0)
  379.                     if rawdata[i - 1] != ';':
  380.                         self.syntax_error("`;' missing in entityref")
  381.                         i = i - 1
  382.                     
  383.                     name = res.group('name')
  384.                     if self._XMLParser__map_case:
  385.                         name = name.lower()
  386.                     
  387.                     if name in self.entitydefs:
  388.                         self.rawdata = rawdata = rawdata[:res.start(0)] + self.entitydefs[name] + rawdata[i:]
  389.                         n = len(rawdata)
  390.                         i = res.start(0)
  391.                     else:
  392.                         self.unknown_entityref(name)
  393.                     self.lineno = self.lineno + res.group(0).count('\n')
  394.                     continue
  395.                 
  396.             elif rawdata[i] == ']':
  397.                 if self.literal:
  398.                     data = rawdata[i]
  399.                     self.handle_data(data)
  400.                     i = i + 1
  401.                     continue
  402.                 
  403.                 if n - i < 3:
  404.                     break
  405.                 
  406.                 if cdataclose.match(rawdata, i):
  407.                     self.syntax_error("bogus `]]>'")
  408.                 
  409.                 self.handle_data(rawdata[i])
  410.                 i = i + 1
  411.                 continue
  412.             else:
  413.                 raise Error('neither < nor & ??')
  414.             continue
  415.             rawdata[i] == '<'
  416.         if i > 0:
  417.             self._XMLParser__at_start = 0
  418.         
  419.         if end and i < n:
  420.             data = rawdata[i]
  421.             self.syntax_error("bogus `%s'" % data)
  422.             if not (self._XMLParser__accept_utf8) and illegal.search(data):
  423.                 self.syntax_error('illegal character in content')
  424.             
  425.             self.handle_data(data)
  426.             self.lineno = self.lineno + data.count('\n')
  427.             self.rawdata = rawdata[i + 1:]
  428.             return self.goahead(end)
  429.         self.rawdata = rawdata[i:]
  430.         if end:
  431.             if not self._XMLParser__seen_starttag:
  432.                 self.syntax_error('no elements in file')
  433.             
  434.             if self.stack:
  435.                 self.syntax_error('missing end tags')
  436.                 while self.stack:
  437.                     self.finish_endtag(self.stack[-1][0])
  438.             
  439.         
  440.  
  441.     
  442.     def parse_comment(self, i):
  443.         rawdata = self.rawdata
  444.         if rawdata[i:i + 4] != '<!--':
  445.             raise Error('unexpected call to handle_comment')
  446.         rawdata[i:i + 4] != '<!--'
  447.         res = commentclose.search(rawdata, i + 4)
  448.         if res is None:
  449.             return -1
  450.         if doubledash.search(rawdata, i + 4, res.start(0)):
  451.             self.syntax_error("`--' inside comment")
  452.         
  453.         if rawdata[res.start(0) - 1] == '-':
  454.             self.syntax_error('comment cannot end in three dashes')
  455.         
  456.         if not (self._XMLParser__accept_utf8) and illegal.search(rawdata, i + 4, res.start(0)):
  457.             self.syntax_error('illegal character in comment')
  458.         
  459.         self.handle_comment(rawdata[i + 4:res.start(0)])
  460.         return res.end(0)
  461.  
  462.     
  463.     def parse_doctype(self, res):
  464.         rawdata = self.rawdata
  465.         n = len(rawdata)
  466.         name = res.group('name')
  467.         if self._XMLParser__map_case:
  468.             name = name.lower()
  469.         
  470.         (pubid, syslit) = res.group('pubid', 'syslit')
  471.         if pubid is not None:
  472.             pubid = pubid[1:-1]
  473.             pubid = ' '.join(pubid.split())
  474.         
  475.         if syslit is not None:
  476.             syslit = syslit[1:-1]
  477.         
  478.         j = k = res.end(0)
  479.         if k >= n:
  480.             return -1
  481.         res = endbracketfind.match(rawdata, k)
  482.         if res is None:
  483.             return -1
  484.         self.handle_doctype(name, pubid, syslit, None)
  485.         return res.end(0)
  486.  
  487.     
  488.     def parse_cdata(self, i):
  489.         rawdata = self.rawdata
  490.         if rawdata[i:i + 9] != '<![CDATA[':
  491.             raise Error('unexpected call to parse_cdata')
  492.         rawdata[i:i + 9] != '<![CDATA['
  493.         res = cdataclose.search(rawdata, i + 9)
  494.         if res is None:
  495.             return -1
  496.         if not (self._XMLParser__accept_utf8) and illegal.search(rawdata, i + 9, res.start(0)):
  497.             self.syntax_error('illegal character in CDATA')
  498.         
  499.         if not self.stack:
  500.             self.syntax_error('CDATA not in content')
  501.         
  502.         self.handle_cdata(rawdata[i + 9:res.start(0)])
  503.         return res.end(0)
  504.  
  505.     __xml_namespace_attributes = {
  506.         'ns': None,
  507.         'src': None,
  508.         'prefix': None }
  509.     
  510.     def parse_proc(self, i):
  511.         rawdata = self.rawdata
  512.         end = procclose.search(rawdata, i)
  513.         if end is None:
  514.             return -1
  515.         j = end.start(0)
  516.         if not (self._XMLParser__accept_utf8) and illegal.search(rawdata, i + 2, j):
  517.             self.syntax_error('illegal character in processing instruction')
  518.         
  519.         res = tagfind.match(rawdata, i + 2)
  520.         if res is None:
  521.             raise Error('unexpected call to parse_proc')
  522.         res is None
  523.         k = res.end(0)
  524.         name = res.group(0)
  525.         if self._XMLParser__map_case:
  526.             name = name.lower()
  527.         
  528.         if name == 'xml:namespace':
  529.             self.syntax_error('old-fashioned namespace declaration')
  530.             self._XMLParser__use_namespaces = -1
  531.             if self._XMLParser__seen_doctype or self._XMLParser__seen_starttag:
  532.                 self.syntax_error('xml:namespace declaration too late in document')
  533.             
  534.             (attrdict, namespace, k) = self.parse_attributes(name, k, j)
  535.             if namespace:
  536.                 self.syntax_error('namespace declaration inside namespace declaration')
  537.             
  538.             for attrname in attrdict.keys():
  539.                 if attrname not in self._XMLParser__xml_namespace_attributes:
  540.                     self.syntax_error("unknown attribute `%s' in xml:namespace tag" % attrname)
  541.                     continue
  542.             
  543.             if 'ns' not in attrdict or 'prefix' not in attrdict:
  544.                 self.syntax_error('xml:namespace without required attributes')
  545.             
  546.             prefix = attrdict.get('prefix')
  547.             if ncname.match(prefix) is None:
  548.                 self.syntax_error('xml:namespace illegal prefix value')
  549.                 return end.end(0)
  550.             if prefix in self._XMLParser__namespaces:
  551.                 self.syntax_error('xml:namespace prefix not unique')
  552.             
  553.             self._XMLParser__namespaces[prefix] = attrdict['ns']
  554.         elif name.lower() == 'xml':
  555.             self.syntax_error('illegal processing instruction target name')
  556.         
  557.         self.handle_proc(name, rawdata[k:j])
  558.         return end.end(0)
  559.  
  560.     
  561.     def parse_attributes(self, tag, i, j):
  562.         rawdata = self.rawdata
  563.         attrdict = { }
  564.         namespace = { }
  565.         while i < j:
  566.             res = attrfind.match(rawdata, i)
  567.             if res is None:
  568.                 break
  569.             
  570.             (attrname, attrvalue) = res.group('name', 'value')
  571.             if self._XMLParser__map_case:
  572.                 attrname = attrname.lower()
  573.             
  574.             i = res.end(0)
  575.             if attrvalue is None:
  576.                 self.syntax_error("no value specified for attribute `%s'" % attrname)
  577.                 attrvalue = attrname
  578.             elif "'" == "'":
  579.                 pass
  580.             elif not "'" == attrvalue[-1:]:
  581.                 if '"' == '"':
  582.                     pass
  583.                 elif '"' == attrvalue[-1:]:
  584.                     attrvalue = attrvalue[1:-1]
  585.                 elif not self._XMLParser__accept_unquoted_attributes:
  586.                     self.syntax_error("attribute `%s' value not quoted" % attrname)
  587.                 
  588.             res = xmlns.match(attrname)
  589.             if res is not None:
  590.                 ncname = res.group('ncname')
  591.                 None[namespace if not attrvalue else ''] = None
  592.                 if not self._XMLParser__use_namespaces:
  593.                     self._XMLParser__use_namespaces = len(self.stack) + 1
  594.                     continue
  595.                 continue
  596.             
  597.             if '<' in attrvalue:
  598.                 self.syntax_error("`<' illegal in attribute value")
  599.             
  600.             if attrname in attrdict:
  601.                 self.syntax_error("attribute `%s' specified twice" % attrname)
  602.             
  603.             attrvalue = attrvalue.translate(attrtrans)
  604.             attrdict[attrname] = self.translate_references(attrvalue)
  605.         return (attrdict, namespace, i)
  606.  
  607.     
  608.     def parse_starttag(self, i):
  609.         rawdata = self.rawdata
  610.         end = endbracketfind.match(rawdata, i + 1)
  611.         if end is None:
  612.             return -1
  613.         tag = starttagmatch.match(rawdata, i)
  614.         if tag is None or tag.end(0) != end.end(0):
  615.             self.syntax_error('garbage in starttag')
  616.             return end.end(0)
  617.         if self._XMLParser__seen_starttag and not (self.stack):
  618.             self.syntax_error('multiple elements on top level')
  619.         
  620.         (k, j) = tag.span('attrs')
  621.         (attrdict, nsdict, k) = self.parse_attributes(tagname, k, j)
  622.         self.stack.append((tagname, nsdict, nstag))
  623.         if self._XMLParser__use_namespaces:
  624.             res = qname.match(tagname)
  625.         else:
  626.             res = None
  627.         if res is not None:
  628.             (prefix, nstag) = res.group('prefix', 'local')
  629.             if prefix is None:
  630.                 prefix = ''
  631.             
  632.             ns = None
  633.             for t, d, nst in self.stack:
  634.                 if prefix in d:
  635.                     ns = d[prefix]
  636.                     continue
  637.             
  638.             if ns is None and prefix != '':
  639.                 ns = self._XMLParser__namespaces.get(prefix)
  640.             
  641.             if ns is not None:
  642.                 nstag = ns + ' ' + nstag
  643.             elif prefix != '':
  644.                 nstag = prefix + ':' + nstag
  645.             
  646.             self.stack[-1] = (tagname, nsdict, nstag)
  647.         
  648.         attrnamemap = { }
  649.         for key in attrdict.keys():
  650.             attrnamemap[key] = key
  651.         
  652.         if self._XMLParser__use_namespaces:
  653.             nattrdict = { }
  654.             for key, val in attrdict.items():
  655.                 okey = key
  656.                 res = qname.match(key)
  657.                 if res is not None:
  658.                     (aprefix, key) = res.group('prefix', 'local')
  659.                     if self._XMLParser__map_case:
  660.                         key = key.lower()
  661.                     
  662.                     if aprefix is not None:
  663.                         ans = None
  664.                         for t, d, nst in self.stack:
  665.                             if aprefix in d:
  666.                                 ans = d[aprefix]
  667.                                 continue
  668.                         
  669.                         if ans is None:
  670.                             ans = self._XMLParser__namespaces.get(aprefix)
  671.                         
  672.                         if ans is not None:
  673.                             key = ans + ' ' + key
  674.                         else:
  675.                             key = aprefix + ':' + key
  676.                     
  677.                 
  678.                 nattrdict[key] = val
  679.                 attrnamemap[key] = okey
  680.             
  681.             attrdict = nattrdict
  682.         
  683.         attributes = self.attributes.get(nstag)
  684.         if attributes is not None:
  685.             for key in attrdict.keys():
  686.                 if key not in attributes:
  687.                     self.syntax_error("unknown attribute `%s' in tag `%s'" % (attrnamemap[key], tagname))
  688.                     continue
  689.             
  690.             for key, val in attributes.items():
  691.                 if val is not None and key not in attrdict:
  692.                     attrdict[key] = val
  693.                     continue
  694.             
  695.         
  696.         method = self.elements.get(nstag, (None, None))[0]
  697.         self.finish_starttag(nstag, attrdict, method)
  698.         if tag.group('slash') == '/':
  699.             self.finish_endtag(tagname)
  700.         
  701.         return tag.end(0)
  702.  
  703.     
  704.     def parse_endtag(self, i):
  705.         rawdata = self.rawdata
  706.         end = endbracketfind.match(rawdata, i + 1)
  707.         if end is None:
  708.             return -1
  709.         res = tagfind.match(rawdata, i + 2)
  710.         if res is None:
  711.             if self.literal:
  712.                 self.handle_data(rawdata[i])
  713.                 return i + 1
  714.             tag = self.stack[-1][0]
  715.             k = i + 2
  716.         else:
  717.             tag = res.group(0)
  718.             if self._XMLParser__map_case:
  719.                 tag = tag.lower()
  720.             
  721.             if self.literal:
  722.                 if not (self.stack) or tag != self.stack[-1][0]:
  723.                     self.handle_data(rawdata[i])
  724.                     return i + 1
  725.             
  726.             k = res.end(0)
  727.         if endbracket.match(rawdata, k) is None:
  728.             self.syntax_error('garbage in end tag')
  729.         
  730.         self.finish_endtag(tag)
  731.         return end.end(0)
  732.  
  733.     
  734.     def finish_starttag(self, tagname, attrdict, method):
  735.         if method is not None:
  736.             self.handle_starttag(tagname, method, attrdict)
  737.         else:
  738.             self.unknown_starttag(tagname, attrdict)
  739.  
  740.     
  741.     def finish_endtag(self, tag):
  742.         self.literal = 0
  743.         while len(self.stack) > found:
  744.             if found < len(self.stack) - 1:
  745.                 self.syntax_error('missing close tag for %s' % self.stack[-1][2])
  746.             
  747.             nstag = self.stack[-1][2]
  748.             method = self.elements.get(nstag, (None, None))[1]
  749.             if method is not None:
  750.                 self.handle_endtag(nstag, method)
  751.             else:
  752.                 self.unknown_endtag(nstag)
  753.             if self._XMLParser__use_namespaces == len(self.stack):
  754.                 self._XMLParser__use_namespaces = 0
  755.             
  756.             del self.stack[-1]
  757.  
  758.     
  759.     def handle_xml(self, encoding, standalone):
  760.         pass
  761.  
  762.     
  763.     def handle_doctype(self, tag, pubid, syslit, data):
  764.         pass
  765.  
  766.     
  767.     def handle_starttag(self, tag, method, attrs):
  768.         method(attrs)
  769.  
  770.     
  771.     def handle_endtag(self, tag, method):
  772.         method()
  773.  
  774.     
  775.     def handle_charref(self, name):
  776.         
  777.         try:
  778.             if name[0] == 'x':
  779.                 n = int(name[1:], 16)
  780.             else:
  781.                 n = int(name)
  782.         except ValueError:
  783.             self.unknown_charref(name)
  784.             return None
  785.  
  786.         if n <= n:
  787.             pass
  788.         elif not n <= 255:
  789.             self.unknown_charref(name)
  790.             return None
  791.         self.handle_data(chr(n))
  792.  
  793.     entitydefs = {
  794.         'lt': '<',
  795.         'gt': '>',
  796.         'amp': '&',
  797.         'quot': '"',
  798.         'apos': ''' }
  799.     
  800.     def handle_data(self, data):
  801.         pass
  802.  
  803.     
  804.     def handle_cdata(self, data):
  805.         pass
  806.  
  807.     
  808.     def handle_comment(self, data):
  809.         pass
  810.  
  811.     
  812.     def handle_proc(self, name, data):
  813.         pass
  814.  
  815.     
  816.     def syntax_error(self, message):
  817.         raise Error('Syntax error at line %d: %s' % (self.lineno, message))
  818.  
  819.     
  820.     def unknown_starttag(self, tag, attrs):
  821.         pass
  822.  
  823.     
  824.     def unknown_endtag(self, tag):
  825.         pass
  826.  
  827.     
  828.     def unknown_charref(self, ref):
  829.         pass
  830.  
  831.     
  832.     def unknown_entityref(self, name):
  833.         self.syntax_error("reference to unknown entity `&%s;'" % name)
  834.  
  835.  
  836.  
  837. class TestXMLParser(XMLParser):
  838.     
  839.     def __init__(self, **kw):
  840.         self.testdata = ''
  841.         XMLParser.__init__(self, **kw)
  842.  
  843.     
  844.     def handle_xml(self, encoding, standalone):
  845.         self.flush()
  846.         print 'xml: encoding =', encoding, 'standalone =', standalone
  847.  
  848.     
  849.     def handle_doctype(self, tag, pubid, syslit, data):
  850.         self.flush()
  851.         print 'DOCTYPE:', tag, repr(data)
  852.  
  853.     
  854.     def handle_data(self, data):
  855.         self.testdata = self.testdata + data
  856.         if len(repr(self.testdata)) >= 70:
  857.             self.flush()
  858.         
  859.  
  860.     
  861.     def flush(self):
  862.         data = self.testdata
  863.         if data:
  864.             self.testdata = ''
  865.             print 'data:', repr(data)
  866.         
  867.  
  868.     
  869.     def handle_cdata(self, data):
  870.         self.flush()
  871.         print 'cdata:', repr(data)
  872.  
  873.     
  874.     def handle_proc(self, name, data):
  875.         self.flush()
  876.         print 'processing:', name, repr(data)
  877.  
  878.     
  879.     def handle_comment(self, data):
  880.         self.flush()
  881.         r = repr(data)
  882.         if len(r) > 68:
  883.             r = r[:32] + '...' + r[-32:]
  884.         
  885.         print 'comment:', r
  886.  
  887.     
  888.     def syntax_error(self, message):
  889.         print 'error at line %d:' % self.lineno, message
  890.  
  891.     
  892.     def unknown_starttag(self, tag, attrs):
  893.         self.flush()
  894.         if not attrs:
  895.             print 'start tag: <' + tag + '>'
  896.         else:
  897.             print 'start tag: <' + tag,
  898.             for name, value in attrs.items():
  899.                 print name + '=' + '"' + value + '"',
  900.             
  901.             print '>'
  902.  
  903.     
  904.     def unknown_endtag(self, tag):
  905.         self.flush()
  906.         print 'end tag: </' + tag + '>'
  907.  
  908.     
  909.     def unknown_entityref(self, ref):
  910.         self.flush()
  911.         print '*** unknown entity ref: &' + ref + ';'
  912.  
  913.     
  914.     def unknown_charref(self, ref):
  915.         self.flush()
  916.         print '*** unknown char ref: &#' + ref + ';'
  917.  
  918.     
  919.     def close(self):
  920.         XMLParser.close(self)
  921.         self.flush()
  922.  
  923.  
  924.  
  925. def test(args = None):
  926.     import sys as sys
  927.     import getopt as getopt
  928.     time = time
  929.     import time
  930.     if not args:
  931.         args = sys.argv[1:]
  932.     
  933.     (opts, args) = getopt.getopt(args, 'st')
  934.     klass = TestXMLParser
  935.     do_time = 0
  936.     for o, a in opts:
  937.         if o == '-s':
  938.             klass = XMLParser
  939.             continue
  940.         if o == '-t':
  941.             do_time = 1
  942.             continue
  943.     
  944.     if args:
  945.         file = args[0]
  946.     else:
  947.         file = 'test.xml'
  948.     if file == '-':
  949.         f = sys.stdin
  950.     else:
  951.         
  952.         try:
  953.             f = open(file, 'r')
  954.         except IOError:
  955.             msg = None
  956.             print file, ':', msg
  957.             sys.exit(1)
  958.  
  959.     data = f.read()
  960.     if f is not sys.stdin:
  961.         f.close()
  962.     
  963.     x = klass()
  964.     t0 = time()
  965.     
  966.     try:
  967.         if do_time:
  968.             x.feed(data)
  969.             x.close()
  970.         else:
  971.             for c in data:
  972.                 x.feed(c)
  973.             
  974.             x.close()
  975.     except Error:
  976.         msg = None
  977.         t1 = time()
  978.         print msg
  979.         if do_time:
  980.             print 'total time: %g' % (t1 - t0)
  981.         
  982.         sys.exit(1)
  983.  
  984.     t1 = time()
  985.     if do_time:
  986.         print 'total time: %g' % (t1 - t0)
  987.     
  988.  
  989. if __name__ == '__main__':
  990.     test()
  991.  
  992.